(search results) GPCE 2014 / Web Home

GPCE Home
GPCE'14 Home

Registration

Program
Keynote
Tech Talk

Poster and Flyer
Organization
Dates
Call for Papers

Grants

Searched: \.*

Results from GPCE14 web

AcceptedPapers (09 Jul 2014 - 09:26 - r1.5 - MatthewFlatt)

Andreas Ruprecht, Bernhard Heinloth and Daniel Lohmann: Automatic Feature Selection in Large-Scale System-Software Product Lines

Benjamin Hess, Markus Pueschel and Thomas Gross: Automatic Locality-Friendly Interface Extension of Numerical Functions

Christian Humer, Christian Wimmer, Christian Wirth, Andreas Woess and Thomas Wuerthinger: A Domain-Specific Language for Building Self-Optimizing AST Interpreters

Eric Walkingshaw and Klaus Ostermann: Projectional Editing of Variational Software

Jaakko Järvi, Gabriel Foust and Magne Haveraaen: Specializing Planners for Hierarchical Multi-Way Dataflow Constraint Systems

James Hill and Dennis Feiock: Pin++: A Object-oriented Framework for Writing Pintools

Karl Smeltzer, Martin Erwig and Ronald Metoyer: A Transformational Approach to Data Visualization

Kenichi Asai: Compiling a Reflective Language Using MetaOCaml

Lei Ma, Cyrille Artho, Cheng Zhang and Hiroyuki Sato: Efficient Testing of Software Product Lines via Centralization (short paper)

Maria Gouseti, Chiel Peters and Tijs Van Der Storm: Extensible Language Implementation with Object Algebras (short paper)

Masato Shioda, Hideya Iwasaki and Shigeyuki Sato: LibDSL: A Library for Developing Embedded Domain Specific Languages in D via Template Metaprogramming

Michael Steindorfer and Jurgen Vinju: Code Specialization for Memory Efficient Hash-Tries

Piotr Danilewski, Marcel Köster, Roland Leißa, Richard Membarth and Philipp Slusallek: Specialization through Dynamic Staging

Sam Kamin, Maria Garzaran, Baris Aktemur, Danqing Xu, Buse Yilmaz and Zhongbo Chen: Optimization by Runtime Specialization for Sparse Matrix-Vector Multiplication

Somayeh Malakuti and Mehmet Aksit: Emergent Gummy Modules: Modular Representation of Emergent Behavior

Vojin Jovanovic, Amir Shaikhha, Sandro Stucki, Vladimir Nikolaev, Christoph Koch and Martin Odersky: Yin-Yang: Concealing the Deep Embedding of DSLs

Banner (01 Jan 2014 - 23:49 - r1.6 - MatthewFlatt)

Help to spread the word about GPCE'13!

Please help us promote GPCE by including the following HTML code in your webpage, which will include the above image link to our website (you can change the width and height proportionally)

CallForPapers (01 May 2014 - 12:28 - NEW - MatthewFlatt)

13th International Conference on Generative Programming: Concepts & Experiences (GPCE'14)

Collocated with ASE 2014 and SLE 2014
Keynote by Nikolai Tillmann

September 15-16, 2014
Västerås, Sweden

Sponsored by SIGPLAN. GPCE'14 proceedings published by ACM.

Important Dates

Submission of papers: May 30, 2014
Author notification: July 7, 2014

Scope

Generative and component approaches and domain-specific abstractions are revolutionizing software development just as automation and componentization revolutionized manufacturing. Raising the level of abstraction in software specification has been a fundamental goal of the computing community for several decades. Key technologies for automating program development and lifting the abstraction level closer to the problem domain are Generative Programming for program synthesis, Domain-Specific Languages (DSLs) for compact problem-oriented programming notations, and corresponding Implementation Technologies aiming at modularity, correctness, reuse, and evolution. As the field matures Applications and Empirical Results are of increasing importance.

The International Conference on Generative Programming: Concepts & Experiences (GPCE) is a venue for researchers and practitioners interested in techniques that use program generation, domain-specific languages, and component deployment to increase programmer productivity, improve software quality, and shorten the time-to-market of software products. In addition to exploring cutting-edge techniques of generative software, our goal is to foster further cross-fertilization between the software engineering and the programming languages research communities.

Topics

GPCE seeks contributions on all topics related to generative software and its properties. As technology is maturing, this year, we are particularly looking for empirical evaluations in this context. Key topics include (but are certainly not limited too):

Generative software
- Domain-specific languages
  (language extension, language embedding, language design, language theory, language workbenches, interpreters, compilers)
- Product lines
  (domain engineering, feature-oriented and aspect-oriented programming, preprocessors, feature interactions)
- Metaprogramming
  (reflection, staging, partial evaluation)
- Program synthesis
- Implementation techniques and tool support
  (components, plug-ins, libraries, metaprogramming, macros, templates, generic programming, run-time code generation, model-driven development, composition tools, code-completion and code-recommendation systems)
Properties of generative software
- Correctness of generators and generated code
  (analysis, testing, formal methods, domain-specific error messages, safety, security)
- Reuse and evolution
- Modularity, separation of concerns, understandability, and maintainability
- Performance engineering, nonfunctional properties
  (program optimization and parallelization, GPGPUs, multicore, footprint, metrics)
- Application areas and engineering practice
  (distributed systems, middleware, embedded systems, patterns, development methods)
Empirical evaluations of all topics above
(user studies, substantial case studies, controlled experiments, surveys, rigorous measurements)

We particularly welcome papers that address some of the key challenges in field, for example

Synthesizing code from declarative specifications
Supporting extensible languages and language embedding
Ensuring correctness and other nonfunctional properties of generated code; proving generators correct
Improving error reporting with domain-specific error messages
Reasoning about generators; handling variability-induced complexity in product lines
Providing efficient interpreters and execution languages
Human factors in developing and maintaining generators

Note on empirical evaluations: GPCE is committed to the empirical evaluation of generative software. Publishing empirical papers at programming-language venues can be challenging. We understand the frustration of authors when, for example, reviews simply recommend repeating entire experiments with human subjects with slight deviations in execution. To alleviate such problems, we have recruited forto program committee experts who routinely work with empirical methods, and we will actively seek external reviews where appropriate. During submissions, authors can optionally indicate that a paper contains substantial empirical work, and we will endeavor have to the paper reviewed by experts familiar with the empirical research methods that are used in the paper. The program-committee discussions will reflect on both technical contributions and research methods. For more context, see also _Hints for Reviewing Empirical Work in Software Engineering_.

Policy: Incremental improvements over previously published work should have been evaluated through systematic, comparative, empirical, or experimental evaluation. Submissions must adhere to SIGPLAN's republication policy (http://www.sigplan.org). Please contact the program chair if you have any questions about how this policy applies to your paper (chairs@gpce.org).

Submitted articles must not have been previously published or currently be submitted for publication elsewhere. The program chairs will apply the principles of the ACM Plagiarism Policy throughout the submission and review process.

Submissions

The submission site is http://www.easychair.org/conferences/?conf=gpce14.

Research papers

10 pages in SIGPLAN proceedings style (sigplanconf.cls, default font size, see http://www.sigplan.org/authorInformation.htm) reporting original and unpublished results of theoretical, empirical, conceptual, or experimental research that contribute to scientific knowledge in the areas listed below (the PC chair can advise on appropriateness).

Authors may choose to submit a paper as short paper of 4 pages or less. The goal of short papers is to promote current work on research and practice. Short papers represent an early communication of research and do not always require complete results as in the case of a full paper. In this way, authors can introduce new ideas to the community, discuss ideas and get early feedback. Please note that short papers are not intended to be position statements. Short papers are included in the proceedings and will be presented with a shorter time slot at the conference.

Papers will be administratively rejected and will not be reviewed if they exceed the page limit or use condensed formatting.

Tool demonstrations

Tool demonstrations should present tools that implement generative techniques, and are available for use. Any of the GPCE topics of interest are appropriate areas for tool demonstrations, although purely commercial tool demonstrations will not be accepted. Submissions have must provide a tool description of 4 pages in SIGPLAN proceedings style (see above) and a demonstration outline including screenshots of up to 4 pages. Tool demonstrations must have the words “Tool Demo” or “Tool Demonstration” in the title, possibly appended in parenthesis. The 4-page tool description will, if the demonstration is accepted, be published in the proceedings. The 4-page demonstration outline will be used by the program committee only for evaluating the submission.

Tech talks

Depending on whether there is space in the program, GPCE may solicit Tech talks. See the GPCE'12 tech talks call for contributions for details. For now, if you are interested in presenting a Tech talk, please contact the chairs (chairs@gpce.org).

Workshops

Workshops will be organized by ASE. Please inform us (chairs@gpce.org) and contact the ASE organizers if you would like to organize a workshop of interest to the GPCE audience.

Organization and Committees

see ConferenceOrganization

CallForTechTalks (04 Mar 2013 - 09:37 - r1.18 - NorbertSiegmund)

CALL FOR TECH TALKS

13th International Conference on Generative Programming: Concepts & Experiences (GPCE'14)

Collocated with ASE 2014 and SLE 2014
Keynote by Nikolai Tillmann

September 15-16, 2014
Västerås, Sweden

Sponsored by SIGPLAN. GPCE'14 proceedings published by ACM.

Important dates

Submission of tech talk proposals: July 2013
Author notification: August 2013

Scope

Tech talks will be about an hour in length; longer than a regular conference talk, but shorter than the customary half or full day tutorials at other conferences. In contrast to research talks, tech talks do not have to present original new research material, but should rather focus on putting research into perspective for a broader audience. In contrast to longer tutorials, these talks cannot be very interactive or rely on the audience participating by using tools. Rather, they should aim to be 'keynote' style presentations, emphasizing the essence (but not avoiding depth).

They can be thought of as distilled tutorials that provide a focused and in-depth treatment of specific research results considered relevant to the GPCE community.

Moreover, the tech talks are included in the conference registration and are not charged separately. We hope that this will ensure high impact of the tech talks.

Submission

If you are interested in presenting a tech talk at GPCE, please send a short proposal (about two pages) to the conference chairs (chairs@gpce.org) by July 2013.

The proposal should consist of

title
name of presenter
abstract (max. 250 words)
biography (max. 250 words)
relevance for GPCE audience (max. 250 words)
outline of tech talk (max. 1 page)

Items 1 to 4 will be used on the website.

We will make a selection of tech talks based on relevance (topic-wise) for the conference and expected interest in the tech talk. Tech talk proposers will be notified of the decision by August 2013.

ConferenceHeader (28 Apr 2014 - 23:17 - r1.23 - MatthewFlatt)

13th International Conference on Generative Programming: Concepts & Experiences (GPCE'14)

Collocated with ASE 2014 and SLE 2014
Keynote by Nikolai Tillmann

September 15-16, 2014
Västerås, Sweden

Sponsored by SIGPLAN. GPCE'14 proceedings published by ACM.

ConferenceOrganization (07 Jan 2014 - 13:36 - r1.31 - MatthewFlatt)

General Chair:

Ulrik Pagh Schultz (University of Southern Denmark, DK)

Program Chair:

Matthew Flatt (University of Utah, USA)

Local Organizer:

Ivica Crnkovic (Mälardalen University, SE)

Program Committee:

Kenichi Asai (Ochanomizu University, JP)
Emilie Balland (INRIA, FR)
Edwin Brady (University of St Andrews, UK)
Dave Clarke (Uppsala University, SE and KU Leuven, BE)
Ewen Denney (SGT / NASA, US)
Sebastian Erdweg (Technische Universität Darmstadt, DE)
Martin Erwig (Oregon State University, US)
Alessandro Garcia (Pontifícia Universidade Católica do Rio de Janeiro, BR)
Anirüddhā Gokhālé (Vanderbilt University, US)
Jeff Gray (University of Alabama, US)
Stefan Hanenberg (Universität Duisburg-Essen, DE)
Jaakko Järvi (Texas A&M University, US)
Jean-Marc Jézéquel (IRISA-University of Rennes, FR)
Emerson Murphy-Hill (North Carolina State University, US)
Nathaniel Nystrom (University of Lugano, CH)
Bruno C. d. S. Oliveira (Hong Kong University, HK)
Hridesh Rajan (Iowa State University, US)
Márcio Ribeiro (Universidade Federal de Alagoas, BR)
Tiark Rompf (Oracle Labs and EPFL, CH)
Grigore Rosu (University of Illinois at Urbana-Champaign, US)
Norbert Siegmund (Universität Passau, DE)
Christian Skalka (University of Vermont, US)
Scott Smith (Johns Hopkins University, US)
Éric Tanter (Universidad de Chile, CL)
Emina Torlak (University of California Berkeley, US)
Laurence Tratt (King's College, UK)

Publicity Chair:

Sebastian Erdweg (Technical University of Darmstadt, DE)

Steering Committee:

Bernd Fischer (SA) (2011-)
Ewen Denney (USA) (2012-)
Matthew Flatt (USA) (2014-)
Jaakko Jarvi (USA) (2010-)
Christian Kästner (USA) (2013-)
Ulrik Pagh Schultz (DK) (2012-)
Eelco Visser (NL), Chair (2008-2012, ex-officio member 2012-)

ConferenceProgram (18 Sep 2014 - 11:45 - r1.37 - MatthewFlatt)

September 14, 2013

FOSD Workshop

September 15, 2013

Welcome and Keynote

08:30-09:00 Welcome and Introduction
09:00-10:00 SLE Keynote: From Language Engineering to Viewpoint Engineering Colin Atkinson

Session 1: Specialization and Modularity (session chair: Ulrik Pagh Schultz)

10:30-11:00 Specializing Planners for Hierarchical Multi-Way Dataflow Constraint Systems Jaakko Järvi, Gabriel Foust and Magne Haveraaen
11:00-11:20 Code Specialization for Memory Efficient Hash-Tries (short paper) Michael Steindorfer and Jurgen Vinju
11:20-11:50 Emergent Gummy Modules: Modular Representation of Emergent Behavior Somayeh Malakuti and Mehmet Aksit
11:50-12:10 Extensible Language Implementation with Object Algebras (short paper) Maria Gouseti, Chiel Peters and Tijs Van Der Storm

Session 2: Variation and Product Lines (session chair: Matthew Flatt)

14:00-14:30 Projectional Editing of Variational Software Eric Walkingshaw and Klaus Ostermann — Best Paper Award
14:30-15:00 Automatic Feature Selection in Large-Scale System-Software Product Lines Andreas Ruprecht, Bernhard Heinloth and Daniel Lohmann
15:00-15:20 Efficient Testing of Software Product Lines via Centralization (short paper) Lei Ma, Cyrille Artho, Cheng Zhang and Hiroyuki Sato

Session 3: DSLs (session chair: Sebastian Erdweg)

16:00-16:30 A Transformational Approach to Data Visualization Karl Smeltzer, Martin Erwig and Ronald Metoyer
16:30-17:00 LibDSL: A Library for Developing Embedded Domain Specific Languages in D via Template Metaprogramming Masato Shioda, Hideya Iwasaki and Shigeyuki Sato
17:00-17:30 Yin-Yang: Concealing the Deep Embedding of DSLs Vojin Jovanovic, Amir Shaikhha, Sandro Stucki, Vladimir Nikolaev, Christoph Koch and Martin Odersky

September 16, 2013

Keynote

09:00-10:00 GPCE Keynote: Programming Cloud-connected Mobile Devices Nikolai Tillmann

Session 4: Specialization and Cross-Cutting (session chair: Kenichi Asai)

10:30-11:00 Automatic Locality-Friendly Interface Extension of Numerical Function Benjamin Hess, Markus Pueschel and Thomas Gross
11:00-11:30 Optimization by Runtime Specialization for Sparse Matrix-Vector Multiplication Sam Kamin, Maria Garzaran, Baris Aktemur, Danqing Xu, Buse Yilmaz and Zhongbo Chen
11:30-12:00 Specialization through Dynamic Staging Piotr Danilewski, Marcel Köster, Roland Leißa, Richard Membarth and Philipp Slusallek

Session 5: Language Tools (session chair: Jaakko Järvi)

14:00-14:30 Compiling a Reflective Language Using MetaOCaml Kenichi Asai
14:30-15:00 A Domain-Specific Language for Building Self-Optimizing AST Interpreters Christian Humer, Christian Wimmer, Christian Wirth, Andreas Woess and Thomas Wuerthinger
15:00-15:30 Pin++: A Object-oriented Framework for Writing Pintools James Hill and Dennis Feiock

Session 6:

16:00-17:00 Building mbeddr: a Language Engineering Experiment (tech talk) Markus Völter
17:00-17:15 Closing remarks

ConferenceRegistration (01 Aug 2011 - 22:13 - r1.5 - PeterKim)

Registration will be done through SPLASH 2011. Stay tuned.

ConferenceVenue (24 Oct 2013 - 21:50 - r1.10 - MatthewFlatt)

GPCE 2013 will be held at Västerås, Sweden, co-located with ASE 2014.

Submission of papers: May 30, 2014 (Anywhere on Earth)
For papers submitted by the deadline, updates will be allowed through June 2, 2014 (Anywhere on Earth)
Paper notification: July 7, 2014
Camera ready papers: August 7, 2014

Conference: September 15-16, 2014

KaestnerTechTalk (08 Aug 2012 - 19:23 - r1.3 - WalterBinder)

Compile-time variability is paramount in many software systems: Users can select desired features and generate a product tailored for their needs. For example, the Linux kernel has over 10000 such compile-time configuration options. Typically organized as software product lines, there are many different implementation mechanisms that can all be regarded as generators that produce products based on variability specifications.

However, variability often implies complexity. Already with few configuration options, we can generate a vast number (easily exceeding billions) of potential products. Checking all products individually using classic testing or analysis techniques is not feasible.

Recently, researchers have begun to adapt existing analysis techniques, such as type checking, model checking, theorem proving, static analysis, and parsing, to incorporate variability. Usually, the idea is to check the entire product line in a single step and to reason about variability locally where it manifests at the code level. When the product line passes the check (e.g., the product line is well-typed), it is guaranteed that all possible generated products pass the check as well (e.g., all products that can be generated are well-typed, too). Such variability-aware analyses take variability information into account, including feature models and implementation artifacts, thus spanning problem and solution space.

In the talk, we provide an overview of concepts for variability-aware analysis, discuss different strategies (brute force, sampling, family-based analysis, feature-based analysis), and show recurring ideas and patterns of how existing analysis are extended for variability. While taking a broad view, we illustrate key ideas and also initial results by means of a number of case studies, including the development of a variability-aware type system and its application to Linux and the application of variability-aware verification techniques to product-line models.

Biography

Christian Kästner is a researcher in the Programming Languages Group at the Philipps University Marburg, Germany. He received his Ph.D. in Computer Science in 2010 from the University of Magdeburg, Germany for his work on virtual separation of concerns, which included developing a variability-aware type system for software product lines. His research focuses on correctness and understanding of systems with variability, including work on implementation mechanisms, tools, different kinds of analyses, feature interactions, and variability mining and refactoring. He is the author or coauthor of over a fifty peer-reviewed scientific publications.

Sven Apel is the leader of the Software Product-Line Group funded by the esteemed Emmy Noether Programme of the German Research Foundation (DFG). The group resides at the University of Passau, Germany. Dr.-Ing. Sven Apel received his Ph. D. in Computer Science in 2007 from the University of Magdeburg, Germany. His research interests include novel programming paradigms, software engineering and product lines, and formal and empirical methods. He is the author or coauthor of over a hundred peer-reviewed scientific publications. Sven Apel has been a program committee member of several highly ranked international conferences. His work received awards by the Ernst Denert Foundation and the Karin Witte Foundation

KeynoteSpeakers (21 Aug 2014 - 16:59 - r1.17 - MatthewFlatt)

Joint GPCE/SLE Keynote

Programming Cloud-connected Mobile Devices

Nikolai Tillmann (Microsoft Research)

We are experiencing a technology shift: Powerful and easy-to-use mobile devices like smartphones and tablets are becoming more prevalent than traditional PCs and laptops. Mobile devices are going to be the first and, in less developed countries, possibly the only computing devices which virtually all people will own and carry with them at all times. Such devices are connected to the cloud most of the time, providing a local view on distributed data. Are the programming languages, environments and paradigms that have served us well for decades the best possible fit for this new world of cloud-connected devices? In this talk, I will present TouchDevelop, a modern software development environment that we have designed from the ground up to fit the new reality. TouchDevelop comes with typed, structured programming language that is built around the idea of only using a touchscreen as the input device to author code. Access to shared data in the cloud, flexible user interfaces, and sensors such as accelerometer and GPS are available as a first-class citizens in the programming language. The TouchDevelop programming environment is available as a web app on Windows tablets, iOS, Android, Windows PCs and Macs, and as a native app on Windows Phone.

Nikolai Tillmann is a Principal Development Lead at Microsoft, Redmond. His main areas of research are program authoring on mobile devices, program analysis, testing, optimization, and verification. At Microsoft Research, he started TouchDevelop, a cross-platform development environment which enables end-users to write programs for mobile devices on mobile devices; try it for yourself at www.touchdevelop.com. He also leads the Pex project, a framework for runtime verification and automatic test case generation for .NET applications based on parameterized unit testing and dynamic symbolic execution. Try out Pex on the web at www.pexforfun.com, or play a coding game based on the Pex engine at www.codehunt.com. Nikolai has a Dipl. Inf. in Computer Science from TU Berlin, Germany.

Joint GPCE/SLE Keynote

From Language Engineering to Viewpoint Engineering

Colin Atkinson (University of Mannheim)

As software systems increase in size and complexity, and are expected to cope with ever more quantities of information from ever more sources, there is an urgent and growing need for a more view-oriented approach to software engineering. Views allow stakeholders to see exactly the right information, at exactly the right time, in a way that best matches their capabilities and goals. However, this is only possible if the information is represented in the optimal languages (i.e. domain- and purpose-specific), with the necessary context information and the optimal manipulation/editing features - that is, if information is viewed from the optimal viewpoints. Rather than merely engineering languages, therefore, software engineers in the future will need to engineer viewpoints, which augment language definitions (e.g. meta-models, syntax ...) with context information (e.g. elision, location, perspective ...) and user-interaction information (e.g. editing pallets, view manipulation services ...). In this talk Colin Atkinson will outline the issues faced in supporting the flexible and efficient engineering of viewpoints and will present some key foundations of a fundamentally view-oriented approach to software engineering.

Colin Atkinson has been the leader of the Software Engineering Group at the University of Mannheim since April 2003. Before that he has held positions at the University of Kaiserslautern, the Fraunhofer Institute for Experimental Software Engineering and the University of Houston - Clear Lake. His research interests are focused on the use of model-driven and component based approaches in the development of dependable and adaptable computing systems. He was a contributor to the original UML development process and is one of the original developers of the deep (multi-level) approach to conceptual modelling. He received his Ph.D. and M.Sc. in computer science from Imperial College, London, in 1990 and 1985 respectively, and his B.Sc. in Mathematical Physics from the University of Nottingham 1983.

MoorInvitedTalk (08 Aug 2012 - 08:01 - r1.3 - KlausOstermann)

How do you improve the behavior of a software team? There will always be team members who are great at quickly producing a new prototype, and others who do a great job of carefully implementing a rock-solid library around a set of new data structures. By analyzing every single contribution of every individual over a long period of time, we can start to understand such differences in coding style. Individuals get suggestions on how to improve their own style, and team leaders can build on everyone’s strength to maximize productivity.

Semmle’s business intelligence product enables this type of detailed analysis of version history, source code, issue tickets, test results and so forth. I will discuss how the technical challenges were overcome, and also the organizational implications.

Biography

Oege de Moor is the CEO of Semmle Ltd. He started his career in programming in 1982 with the development of a word processor for Arabic and Hebrew. After an undergraduate degree in computer Science at Utrecht (the Netherlands), he did his graduate work at Oxford. At present he is a professor of computer science there, and a fellow of Magdalen College. He has held visiting appointments at Chalmers University (Sweden), the University of Tokyo (Japan), and Microsoft Research (Redmond and Cambridge).

P103Bauer (07 Aug 2012 - 20:16 - NEW - WalterBinder)

In the adaptation-based programming (ABP) paradigm, programs may contain variable parts (function calls, parameter values, etc.) that can be take a number of different values. Programs also contain reward statements with which a programmer can provide feedback about how well a program is performing with respect to achieving its goals (for example, achieving a high score on some scale). By repeatedly running the program, a machine learning component will, guided by the rewards, gradually adjust the automatic choices made in the variable program parts so that they converge toward an optimal strategy.

ABP is a method for semi-automatic program generation in which the choices and rewards offered by programmers allow standard machine-learning techniques to explore a design space defined by the programmer to find an optimal instance of a program template. ABP effectively provides a DSL that allows non-machine-learning experts to exploit machine learning to generate self-optimizing programs.

Unfortunately, in many cases the placement and structuring of choices and rewards can have a detrimental effect on how an optimal solution to a program-generation problem can be found. To address this problem, we have developed a dataflow analysis that computes influence tracks of choices and rewards. This information can be exploited by an augmented machine-learning technique to ignore misleading rewards and to generally attribute rewards better to the choices that have actually influenced them. Moreover, this technique allows us to detect errors in the adaptive program that might arise out of program maintenance. Our evaluation shows that the dataflow analysis can lead to improvements in performance.

P112Efftinge (07 Aug 2012 - 20:21 - NEW - WalterBinder)

Xtext is an open-source framework for implementing external, textual domain-specific languages (DSLs). So far, most DSLs implemented with Xtext and similar tools focus on structural aspects such as service specifications and entities. Because behavioral aspects are significantly more complicated to implement, they are often delegated to general-purpose programming languages. This approach introduces complex integration patterns and the DSL's high level of abstraction is compromised.

We present Xbase as part of Xtext, an expression language that can be reused via language inheritance in any DSL implementation based on Xtext. Xbase expressions provide both control structures and program expressions in a uniform way. Xbase is statically typed and tightly integrated with the Java type system. Languages extending Xbase inherit the syntax of a Java-like expression language as well as language infrastructure components, including a parser, an unparser, a linker, a compiler and an interpreter. Furthermore, the framework provides integration into the Eclipse IDE including debug and refactoring support.

The application of Xbase is presented by means of a domain model language which serves as a tutorial example and by the implementation of the programming language Xtend. Xtend is a functional and object-oriented general purpose language for the Java Virtual Machine (JVM). It is built on top of Xbase which is the reusable expression language that is the foundation of Xtend.

P11Thum (07 Aug 2012 - 17:02 - NEW - WalterBinder)

A software product line is a set of similar software products that share a common code base. While software product lines can be implemented efficiently using feature-oriented programming, verifying each product individually does not scale, especially if human effort is required (e.g., as in interactive theorem proving). We present a family-based approach of deductive verification to prove the correctness of a software product line efficiently. We illustrate and evaluate our approach for software product lines written in a feature-oriented dialect of Java and specified using the Java Modeling Language. We show that the theorem prover KeY can be used off-the-shelf for this task, without any modifications. Compared to the individual verification of each product, our approach reduces the verification time needed for our case study by more than 85%.

P122Rafkind (07 Aug 2012 - 20:26 - NEW - WalterBinder)

Honu is a new language that fuses traditional algebraic notation (e.g., infix binary operators) with Scheme-style language extensibility. A key element of Honu's design is an enforestation parsing step, which converts a flat stream of tokens into an S-expression-like tree, in addition to the initial "read" phase of parsing and interleaved with the "macro-expand" phase. We present the design of Honu, explain its parsing and macro-extension algorithm, and show example syntactic extensions.

P132Walkingshaw (07 Aug 2012 - 20:31 - NEW - WalterBinder)

We present a formal calculus for modeling and implementing variation in software. It unifies the compositional and annotative approaches to feature implementation and supports the development of abstractions that can be used to directly relate feature models to their implementation. Since the compositional and annotative approaches are complementary, the calculus enables implementers to use the best combination of tools for the job and focus on inherent feature interactions, rather than those introduced by biases in the representation. The calculus also supports the abstraction of recurring variational patterns and provides a metaprogramming platform for organizing variation in artifacts.

P1Damiani (07 Aug 2012 - 16:56 - NEW - WalterBinder)

Delta-oriented programming (DOP) is a flexible approach for implementing software product lines (SPLs). DOP SPLs are implemented by a code base (a set of delta modules encapsulating changes to object-oriented programs) and a product line declaration (providing the connection of the delta modules with the product features). In this paper, we extend DOP by the capability to switch the implemented product configuration at runtime and present a formal foundation for dynamic DOP. A dynamic DOP SPL is a DOP SPL with a dynamic reconfiguration graph that specifies how to switch between different feature configurations. Dynamic DOP supports (unanticipated) software evolution such that at runtime, the product line declaration, the code base and the dynamic reconfiguration graph can be changed in any (unanticipated) way that preserves the currently running product. The type system of our dynamic DOP core calculus ensures that the dynamic reconfigurations lead to type safe products and do not cause runtime type errors.

P21Ryssel (07 Aug 2012 - 17:06 - NEW - WalterBinder)

When using product lines, whose variability models are based on derived features, e.g., Simulink variant objects, the dependencies among the features are only described implicitly. This makes it difficult to verify the mapping of the features to the solution space and to create a comprehensive overview of the feature dependencies like in a feature model. In this paper, an OWL-based approach is presented, which permits the automatic verification of the feature mapping and an automatic feature model synthesis for derived features using OWL reasoning and formal concept analysis.

P31Rayside (07 Aug 2012 - 19:34 - NEW - WalterBinder)

A technique for synthesizing iterators from declarative abstraction functions written in a relational logic specification language is described. The logic includes a transitive closure operator that makes it convenient for expressing reachability queries on linked data structures. Some optimizations, including tuple elimination, iterator flattening, and traversal state reduction, are used to improve performance of the generated iterators.

A case study demonstrates that most of the iterators in the widely used JDK Collections classes can be replaced with code synthesized from declarative abstraction functions. These synthesized iterators perform competitively with the hand-written originals.

In a user study the synthesized iterators always passed more test cases than the hand-written ones, were almost always as efficient, usually took less programmer effort, and were the qualitative preference of all participants who provided free-form comments.

P41Hulette (07 Aug 2012 - 19:40 - NEW - WalterBinder)

Twig is a language for writing typemaps, programs which transform the type of a value while preserving its underlying meaning. Typemaps are typically used by tools that generate code, such as multi-language wrapper generators, to automatically convert types as needed. Twig builds on existing typemap tools in a few key ways. Twig's typemaps are composable so that complex transformations may be built from simpler ones. In addition, Twig incorporates an abstract, formal model of code generation, allowing it to output code for different target languages. We describe Twig's formal semantics and show how the language allows us to concisely express typemaps. Then, we demonstrate Twig's utility by building an example typemap.

P50Axelsen (07 Aug 2012 - 19:45 - NEW - WalterBinder)

Package Templates (PT) is a mechanism designed for writing reusable modules, called templates, each consisting of a set of classes that can be adapted to their use in a program through compile-time specialization. A template must be instantiated in a program before its classes can be used. The mechanism supports type-safe renaming, merging, type parameterization and refinement in the form of static additions and overrides that are orthogonal to the corresponding concepts of ordinary inheritance.

In this paper, we consider PT as an extension to Java, and a PT program will then consist of a number of Java packages and templates, where templates are instantiated in packages or other templates. Our aim and main contribution is to define the meaning of such a program, and to show that this definition is consistent. We first show this for a core subset of PT, C-PT, and define a set of source-to-source transformations for converting C-PT programs to plain Java programs using semantics we have described informally in previous papers. We can then define the meaning of a C-PT program in terms of the resulting Java program. Thus, we have to verify that the transformations will always convert a legal C-PT program to a legal Java program. Finally, we briefly discuss how this approach can be extended to full PT.

A main challenge is to preserve externally visible names (for classes, methods and fields), and at the same time prevent unwanted subsequent rebindings caused e.g. by overload resolution in the Java compiler. Names that are bound to declarations in a template should not be rebound to different declarations by subsequent compositions or adaptions.

In addition to defining the runtime semantics of PT constructs in terms of their translation to Java, the transformation rules can also be seen as a high-level approach to how a compiler for this language might be implemented.

P60Spacek (07 Aug 2012 - 19:51 - NEW - WalterBinder)

In the context of Component-based Programming, which addresses the implementation stage of a component-based software engineering development process, this paper describes a specification and an operational integration of an inheritance system into a self-contained new component-based programming language named COMPO. Our proposal completes and extends related works by making it possible to apply inheritance to the full description of components, i.e. both to structural (description of provisions and requirements, of component architecture) and behavioral (full implementations of services) parts in component descriptions. Inheritance in COMPO is designed to be used in conjunction with composition to maximize reuse capabilities and expressive power. COMPO implementation proposes a clear operational solution for inheritance and for achieving and testing substitutions.

P70Zhang (07 Aug 2012 - 19:56 - NEW - WalterBinder)

Component-based development promotes a software development process that focuses on component reuse. How to describe a desired component before searching in the repository? How to find an existing component that fulfills the required functionalities? How to capture the system personalization based on its constitutive components' customization? To answer these questions, this paper claims that components should be described using three different forms at three development stages: architecture specification, configuration and assembly. However, no architecture description language proposes such a detailed description for components that supports such a three step component-based development. This paper proposes a three-level ADL, named Dedal, that enables the explicit and separate definitions of component roles, component classes, and component instances.

P80Freeman (07 Aug 2012 - 20:02 - NEW - WalterBinder)

HotDrink is a JavaScript library for constructing forms, dialogs, and other common user interfaces for Web applications. With HotDrink, instead of writing event handlers, developers declare a "view-model" in JavaScript and a set of "bindings" between the view-model and the HTML elements comprising the view. These specifications tend to be small, but they are enough for HotDrink to provide a fully operational GUI with multi-way dataflows, enabling/disabling of values, activation/deactivation of commands, and data validation. HotDrink implements these rich behaviors, expected of high-quality user interfaces, as generic reusable algorithms. This paper/tool demonstration introduces developers to the HotDrink library by stepping through the construction of an example web application GUI.

The library is a concrete realization of our prior work on the "property models" approach to declarative GUI programming. To encourage adoption among developers, we have packaged the technology following established web programming conventions.

P84Riche (07 Aug 2012 - 20:08 - NEW - WalterBinder)

A classical approach to program derivation is to progressively extend a simple specification and then incrementally refine it to an implementation. We claim this approach is hard or impractical when reverse engineering legacy software architectures. We present a case study that shows optimizations and pushouts - in addition to refinements and extensions - are essential for practical stepwise development of complex software architectures.

P93Bagheri (07 Aug 2012 - 20:11 - NEW - WalterBinder)

Developing applications that use complex platforms for functionalities such as authentication and messaging is hard. Model-driven engineering promises to help, but transformation systems are themselves hard to produce. We contribute a new approach using constraint-based synthesis of partial code frameworks that developers complete by hand without the need for hand-coded transformation systems. Rather, synthesis is driven by formal, partial specifications of target platforms and application architectures, and by design (code) fragments encoding application-specific platform usage patterns. We present results of an early evaluation using the case study method to test hypotheses of feasibility and potential industrial utility, using a laboratory model of a nationwide health information network as a subject system.

Poster (07 Mar 2014 - 13:26 - r1.11 - SebastianErdweg)

Please print a poster and some flyers, and share them with others in your institution or at the next conference you attend.

TanterInvitedTalk (09 Aug 2012 - 13:58 - NEW - WalterBinder)

Aspect-oriented programming languages support the modular definition of crosscutting abstractions. In most languages, this is achieved through pointcuts, which provide a means for quantifying over execution events in order to implicitly trigger advice. Notably, an advice is more than a simple event handler because of its ability to override the underlying computation. Unrestricted quantification and arbitrary advice computation are powerful but dangerous.

In this talk we look at a number of approaches to tame aspects in order to retain their benefits without sacrificing important software engineering properties, like modular reasoning, separate development, type soundness, and controlled interferences. Specifically, we report on advances in scoping, interfaces, typing and effects, highlighting recent achievements as well as open challenges.

Biography

Éric Tanter is an Associate Professor in the Computer Science Department of the University of Chile, where he co-leads the PLEIAD laboratory. He received the PhD degree in computer science from both the University of Nantes and the University of Chile (2004). His research interests include programming languages and tool support for modular and adaptable software.

TechTalk (28 Jul 2014 - 12:26 - NEW - MatthewFlatt)

Building mbeddr: a Language Engineering Experiment

Markus Völter

Over the last four years a team at fortiss and itemis have built mbeddr, an extensible set of integrated languages for embedded software development. mbeddr rests on the JetBrains MPS language workbench. MPS has a projectional editor, which enables wide-ranging language modularity and flexible notations that include text, prose, tables, mathematics and graphics. As far as we know, mbeddr is the largest and most sophisticated system built on top of a projectional language workbench. In this talk I will recap the "mbeddr experience", good and bad. I will show mbeddr and some of the systems built with it, and argue why we think it could not have been built with other existing language workbenches. I will also point out the problems we had to fight with during mbeddr's construction, including those created by MPS as well as those that resulted from our own ignorance. I will close the talk by indentifying some of the areas in which MPS could be (or is currently being) improved: some of them are certainly interesting topics for academic research.

Tutorial1ProjectFortress (17 Aug 2010 - 15:29 - r1.3 - RobEconomopoulos)

Project Fortress: A Growable Language for Scientists and Engineers

Sukyoung Ryu

Abstract

We can think of a programming language as a vocabulary of words and a set of rules that deﬁne how to combine words into meaningful constructs. Creating a vocabulary and a set of rules that allow programmers to express their ideas clearly and concisely is one of the main goals of language design. However, it is diﬃcult to anticipate the vocabulary and the set of rules that are suitable for solving various problems. It often depends on domain-speciﬁc applications, new hardware platforms, and any unexpected feature requests. Therefore, a language should grow over time to accommodate the changing needs of its users.

Fortress is a new programming language designed for growth by community instead of a single core team. It provides mathematical syntax to enable scientists and engineers to write programs in a notation they are accustomed to. It also provides built-in support for parallel programming. Moreover, its macro system allows for the language growth by extending the syntax and semantics of Fortress.

In designing Fortress, we have adopted the following design strategy: “Whenever possible, implement a proposed language feature in a library rather than building it into the compiler.” For this approach to work, library writers must have substantial ﬂexibility and control over both syntax and semantics. By designing the language for growth, we are designing it for community participation and development. Hence, we have made Project Fortress open source, and are collaborating on its development with many groups and individuals all over the world.

Please come take it for a spin, or pitch in and help us grow!

Author biography

Sukyoung Ryu is an Assistant Professor at the Computer Science Department of KAIST (Korea Advanced Institute of Science and Technology). Before joining KAIST in December 2009, she worked as a Member of Technical Staﬀ in Sun Microsystems Laboratories, where she worked on formally designing and developing the Fortress programming language. Before that, she was a Research Associate in Computer Science at Harvard, where she worked on the Debugging Everywhere project. She received her Ph.D. (2001), M.S. (1996), and B.S. (1995), in Computer Science from KAIST. Her most recent research focuses on developing language features that are both useful in practice and proven to be sound. She led the effort to construct the core calculi of the Fortress language, to improve the Fortress prose speciﬁcation, and to build a full-ﬂedged parser for Fortress that runs entirely on the JVM.

Tutorial2MegaMedeling (17 Aug 2010 - 10:11 - r1.2 - RobEconomopoulos)

(Mega)modeling Software Language Artifacts

Jean-Marie Favre, Dragan Gašević, Ralf Lämmel

Description

Modern software is typically made of heterogeneous sets of software artifacts including for instance databases, programs, transformations, grammars, models and metamodels, compilers, interpreters, formats, ontologies, frameworks, APIs, schemas, configuration files, makefiles, etc. In practice particular languages, tools, implementations, and standards are used such as SQL DDL, Saxon, XLST, Java, Hibernate, XSD, OWL, DOM, Antlr, UML, XMI, Ecore, Awk, and so on. In the absence of a conceptual framework it is difficult to understand the relationships between these software artifacts, if any. The goal of this tutorial is to provide such a framework, showing that the similarity and relationships between techniques can be modeled at a high level of abstraction, and even more importantly that recurring patterns occur in such models. Some of these patterns, for instance those involving “bridges” between technologies, would be really difficult to grasp without a proper conceptualization. As a result software engineers and researchers usually find it hard to understand the intricacies of technologies that are out of their area of expertise and it is more than likely that they do not realize the analogies that exist between heterogeneous technologies. This tutorial aims to unveil these recurring patterns and to show participants coming from different horizons how to model the technologies they design or work with in an uniform way and how to situate them into the overall software language landscape.

In the first part of the tutorial, the notions of software languages and technical spaces are briefly presented with a special emphasis on their unifying character. Then fundamental relations such RepresentationOf and ElementOf are introduced forming the basis of a (mega)modeling framework. Recurrent patterns based on these relations are then presented, allowing to describe for instance the “conformance” relation between let’s say a program and a grammar, an xml file and an xsd schema, or an uml model and its metamodel, etc. More complex patterns such as bridges between technologies (e.g. XML <==> Relational, OO <==> XML, etc.) are defined following the same approach. Though this notion of bridges seems easy to grasp informally at the first sight, it often leads to a rather large and complex set of technologies that are hard to understand and compare without an appropriate framework.

In the second part of the tutorial, the use of (mega)modeling framework is illustrated through its application in three different technical spaces: Grammarware, Modelware and Ontologyware. Concrete examples of various degree of complexity are provided in each case, with again an emphasis on similarities between technical spaces. The hope of this approach is that it should be possible for someone with some knowledge in technical spaces (let’s say grammarware) to improve significantly his or her comprehension about another space (let’s say ontologyware), and this by virtue of analogy. It is our believe that the (mega)modeling approach, by raising the level of abstraction and focusing on essential software language concepts, enables both to better understand complex structures involving many heterogeneous software artifacts, but also to better apprehend new technologies coming from other spaces.

Author bios

Jean-Marie Favre is a software anthropologist and a software language archeologist. He is principal scientist at One Tree Technologies. He has published numerous papers and coedited a book (in French) Beyond MDA: Model Driven Engineering. He has given tutorials and keynotes in more than dozen of international events and summer schools and has organized various national and international events. His research interests include software language engineering, software linguistics, software evolution and reverse engineering, model driven engineering and research 2.0.

Dragan Gašević is a Canada Research Chair in Semantic Technologies and an Associate Professor in the School of Computing and Information Systems at Athabasca University. His research interests include semantic technologies, software language engineering, technology-enhanced learning, and service- oriented architectures. He has (co-)authored numerous research papers and is a led author of the book "Model Driven Engineering and Ontology Development." He has given tutorials at many well-known conferences such as WWW, ISWC, and CAiSE.

Ralf Lämmel is Professor of Computer Science at University of Koblenz-Landau. In his career, he also served at Microsoft Corp., Free University of Amsterdam, Dutch Center for Mathematics and Computer Science (CWI), and University of Rostock. Ralf Lämmel is generally interested in the combination of software engineering and programming languages. Together with the other tutorial speakers and further researchers, he is one of the founding fathers of the SLE conference. He is one of the founding fathers of the summer school series GTTSE--Generative and Transformational Techniques on Software Engineering.

Tutorial3EmbeddedDSLs (18 Aug 2010 - 11:59 - r1.3 - RobEconomopoulos)

Embedded Domain-speciﬁc Language Implementation using Dependent Types

Edwin Brady

Abstract

Domain-speciﬁc languages (DSLs) are programming languages designed for solving problems in a particular domain. By providing suitable abstractions, they allow experts to focus on solving high-level problems without being concerned with low-level programming details. Embedded domain-speciﬁc languages (EDSLs) are an emerging implementation technique, in which features of a host language, for example parsing or code generation, are exploited by the DSL implementation. In this way, EDSLs can be implemented much more rapidly than their standalone equivalents and can take advantage of compiler optimisations and other implementation effort in the host.

Dependent types allow types to be predicated on values. Using dependent types, a programmer can ascribe a precise type to a program, for example that concatenating lists of length n and m yields a list of length n + m, or that sorting a list of length n yields a list of length n which is a permutation of its input satisfying a given ordering. In this way, types can be viewed as a form of speciﬁcation, veriﬁed by the type checker.

Using a dependently typed language as the host for an EDSL brings additional beneﬁts. Not only can we reuse the host language’s parser and code generator, we can exploit its type system to express properties of the EDSL and guarantee their correctness. In this tutorial I will introduce I DRIS, a dependently typed functional programming language. I will give practical examples of dependently type programs, culminating in the construction of an EDSL for network protocol implementation.

Author biography

Edwin Brady is a SICSA Advanced Research Fellow in Computer Science at the University of St Andrews, where he has worked since receiving his PhD from the University of Durham in 2005. His research interests include functional programming with dependent types, type theory, program generation and programming language design and implementation. His previous work has included compilation and optimisation techniques for dependently typed functional programming languages. This has important applications in the veriﬁcation of safety-critical systems; he has also been closely involved with the Hume project (http://www.hume-lang.org/), applying dependent type systems to the correct implementation of safety-critical embedded systems with limited memory. He is the main developer of I DRIS (http://www.idris-lang.org/), a functional language with dependent types intended for systems programming, and contributes to the development of Epigram (http://www.e-pig.org/). His recent work has focused on the practical applications of dependently typed programming, using I DRIS to implement domain-speciﬁc languages for veriﬁed network protocols, data formats, and resource aware systems in general.

Tutorial4AgileEfficientDSLs (17 Aug 2010 - 15:27 - r1.3 - RobEconomopoulos)

Agile and Efﬁcient Domain-Speciﬁc Languages using Multi-stage Programming in Java Mint

Mathias Ricken, Edwin Westbrook

Abstract

Domain-specific languages (DSLs) are a powerful productivity tool because they allow domain experts, who are not necessarily programming experts, to quickly develop programs. DSL implementations have unique constraints for programming languages because they must be efficient, in order to ensure high productivity, but they must also be agile, in order to meet the rapidly changing demands of their domains. In this tutorial we show how multi-stage programming (MSP) can be used to build staged interpreters, which combine the agility of interpreters with the efficiency of compilers. The tutorial is conducted in Java Mint, an multi-stage Java based on recent work incorporating MSP into imperative object-oriented languages. In the first half of the tutorial, we introduce MSP by demonstrating how to write a staged interpreter for a number of basic language constructs, such as recursive functions, conditionals, and let expressions. In the second half, we extend our staged interpreter to take advantage of several well-known compiler optimizations, including type inference, constant folding, and static parallel loop scheduling. We highlight the opportunities afforded by using MSP with object-oriented design to quickly create efficient DSL implementations.

Author bios

Mathias Ricken is a doctoral candidate in the Programming Languages Team at Rice University and one of the principal developers of the DrJava integrated development environment. His research interests include concurrent programming, extending the Java language, and computer science education. He is the developer of the Concutest concurrent unit testing framework and has created various experimental extensions of Java to address, for instance, programming with meta-data. Currently, Mathias is contributing to Java Mint, a multi-stage extension of Java that allows safe and expressive statically typed program generation and specialization in an imperative language setting.

Edwin Westbrook is a post-doctoral researcher at Rice University. His primary interests are in developing techniques for implementing and verifying properties of domain-speciﬁc languages (DSLs). He has worked on a number of projects in this area, including: Cinic, a type theory for building machine-checked proofs of properties of DSLs using a new approach to higher-order abstract syntax; Java Mint, a multi-stage version of Java used for efﬁcient implementations of DSLs; and Acumen, a DSL for designing cyber-physical systems.

Tutorial5OntologiesAndSE (17 Aug 2010 - 10:14 - r1.2 - RobEconomopoulos)

Ontologies and Software Language Engineering

Dragan Gašević, Fernando Silva Parreiras, Tobias Walter

Abstract

Trying to advance the current practices for sharing data, resources and knowledge on the Web, the research community has been researching challenges around the idea of the Semantic Web. The central component of the Semantic Web are ontologies, commonly deﬁned as formal and explicit definitions of shared domain conceptualizations. To have an interoperable and standardized set of technologies, the Semantic Web research oﬀered a stack of standards and tools including automated reasoners and ontology languages, i.e., languages to describe formally a domain of discourse. This stack of standards and tools is popularly called semantic technologies. Among ontology languages, the Web Ontology Language (OWL) [4] is the most prominent.

Mainly, due to the similarities in the design of OWL and object-oriented languages, the research community started exploring a potential synergy. Indeed, OWL provides important features complementary to UML class-based modeling and OCL that improve software languages: it allows diﬀerent ways of describing classes; it handles these descriptions as ﬁrst-class entities; it provides additional constructs like transitive closure for properties; and it enables dynamic classiﬁcation of objects based upon class descriptions.

The most notable work has been done on integrating ontologies and model-driven engineering, especially, for the tasks related to model-driven language engineering. As the OWL language is based on description logic, standard ontology reasoners can be used for various types of processing of software languages such as consistency checking, constraint validation, and query processing and with applications in different software engineering areas such as component-based software development, software product lines, or requirements engineering. For example, the knowledge encoded in OWL evolves independently of the execution logic, i.e., developers maintain class descriptions in the ontology and not in the software. Moreover, developers may use class descriptions to semantically query the domain. Semantic query plays an important role where shared terminologies, interoperability and consistency detection are required.

Striving to introduce the basics and potentials for ontologies for software language engineering, this tutorial aims to:

deﬁne ontologies and the OWL language;
describe basics of description logics-based reasoning designed for ontology languages;
describe the current eﬀorts on relations between the OWL language and languages such as UML, MOF and OCL; and
illustrate applications of ontology-enhanced software

languages for software design patterns, software product lines, domain-speciﬁc languages, and software language reﬁnement.

After the tutorial, participants will be able (1) to understand the concepts of ontologies, OWL language and its formal reasoning potentials; (2) to realize the valued added by ontology-enabled software languages and (3) to identify potential applications for semantic technologies in software development and diﬀerent software language engineering approaches other than those based on model-driven engineering principles.

References

[1] Gaševic, Dragan, Djuric, Dragan, Devedžic, Vladan. Model Driven Engineering and Ontology Development. Springer, Berlin, 2. edition, 2009.

[2] F. Silva Parreiras and S. Staab. Using Ontologies with UML Class-based Modeling: The TwoUse Approach. Data Knowl. Eng. in press.

[3] F. Silva Parreiras, S. Staab, and A. Winter. Improving design patterns by description logics: A use case with abstract factory and strategy. In Modellierung 2008, volume P-127 of LNI, pages 89–104. GI, 2008.

[4] W3C OWL Working Group. OWL 2 Web Ontology Language Document Overview. W3C Working Draft 27 March 2009. Available at http://www.w3.org/TR/2009/WD-owl2-overview-20090327//.

[5] T. Walter, F. Silva Parreiras, and S. Staab. OntoDSL: An Ontology-Based Framework for Domain-Speciﬁc Languages. In Model Driven Engineering Languages and Systems, 12th International Conference, MODELS 2009, volume 5795, pages 408–422. Springer, 2009.

Author bios

Fernando Silva Parreiras, pursues his PhD since the beginning of 2006 under the supervision of Prof. Steﬀen Staab. He is the leader of the Special Interest Group Software Web at the Web Science and Technology Institute (WeST) at the University of Koblenz-Landau, Germany. He has been investigating the integration of model-driven engineering and Ontology in the scope of the EU project MOST. His related publications include papers in Modellierung’2008, ER’2008, ICSC’2009, MoDELS’2009 and ECMFA 2010. He has served as program committee member of conferences like SLE and and workshops like ONTOSE and SWESE and as organizer of the TWOMDE workshop.

Dragan Gašević is a Canada Research Chair in Semantic Technologies and an Associate Professor in the School of Computing and Information Systems at Athabasca University. He is also an Adjunct Professor in the School of Interactive Arts and Technology at Simon Fraser University and an associated research member of the GOOD OLD AI Research Network at the University of Belgrade. He is a recipient of Alberta Ingenuity’s 2008 New Faculty Award. His research interests include semantic technologies, software language engineering, technology-enhanced learning, and service-oriented architectures. He has (co-)authored more than 200 research papers and delivered more than 10 tutorials at major conferences such as WWW, MODELS, CAiSE, and ISWC. He has been serving on editorial boards of three international journals and has edited special issues in journals such as IET Software and IEEE TSE. He has been the organizer, chair, and member of program committees of many international conferences.

Tobias Walter is PhD. student at the University of Koblenz-Landau under the supervision of Prof. Dr. Jürgen Ebert and Prof. Dr. Steﬀen Staab. Currently he is member of the Institute for Software Technology and the Institute for Web Science and Technology. Here, his research focuses on the combination of domain-speciﬁc modeling languages and diﬀerent ontology technologies. Further he is interested in the design and use of new software modelling languages and its implementation in tools. From 2008 he is contributing to the MOST project where he is investigating the conceptual integration of Model-Driven Architecture (MDA) and Ontologies. His related publications include papers at MoDELS’2009, ECMFA’2010, WC-DSL’2009, ICSC’2009 and different workshops.

Tutorial6MPS (17 Aug 2010 - 10:16 - r1.2 - RobEconomopoulos)

Language Definition and Extension with MPS

Markus Völter

Abstract

Language definition and extension is a hot topic. Using modular languages, where a program can use concepts from different language modules as needed, promises significantly increased language usability as well as an integration between general purpose (programming) and domain-specific (modeling) concepts and tools.

JetBrains MPS is an open source language workbench that uses projectional editing as opposed to parsing techniques. In MPS, languages are defined via structure, projection rules, transformation rules and type systems.

In this tutorial I will provide a brief overview about how MPS works and what you can do with it. I will show how to build an external DSL, how to integrate the external DSL with Java, and how to extend an existing programming language with a new statement. To round it off, I will demo a non-trivial set of languages for embedded software development. 90% of the tutorial will be live demos.

Note that even if you don't plan to work with MPS specifically, this tutorial will provide a good overview of projectional editing.

Author biography

Markus Völter works as an independent researcher, consultant and coach for itemis AG in Stuttgart, Germany. His focus is on software architecture, model-driven software development and domain specific languages as well as on product line engineering. Markus also regularly writes (articles, patterns, books) and speaks (trainings, conferences) on those subjects. Contact him via voelter@acm@org or www.voelter.de.

VenueAccomodation (20 Jul 2012 - 13:25 - NEW - KlausOstermann)

Information about the GPCE venue has been prepared by the local organizers here.

For hotel reservations you can use the Registration.

WebChanges (05 Dec 2004 - 11:28 - r1.3 - MartinBravenboer)

Poster for display (DIN A3) (11.5in x 17.5in)

Flyer for hand out (DIN A4)

Conference Program	18 Sep 2014 - 11:45	Matthew Flatt
Keynote Speakers	21 Aug 2014 - 16:59	Matthew Flatt
Web Left Bar	11 Aug 2014 - 14:44	Matthew Flatt
Tech Talk	28 Jul 2014 - 12:26	Matthew Flatt
Accepted Papers	09 Jul 2014 - 09:26	Matthew Flatt
Gpce Registration	07 Jul 2014 - 12:59	Matthew Flatt
Important Dates	30 May 2014 - 08:51	Matthew Flatt
Web Home	09 May 2014 - 12:55	Rob Vermaas
Call For Papers	01 May 2014 - 12:28	Matthew Flatt
Conference Header	28 Apr 2014 - 23:17	Matthew Flatt
Poster	07 Mar 2014 - 13:26	Sebastian Erdweg
Conference Organization	07 Jan 2014 - 13:36	Matthew Flatt
Web Preferences	01 Jan 2014 - 23:55	Matthew Flatt
Banner	01 Jan 2014 - 23:49	Matthew Flatt
Conference Venue	24 Oct 2013 - 21:50	Matthew Flatt
Grants	04 Apr 2013 - 16:10	Norbert Siegmund
Call For Tech Talks	04 Mar 2013 - 09:37	Norbert Siegmund
Web News	26 Nov 2012 - 15:39	Christian Kaestner
Tanter Invited Talk	09 Aug 2012 - 13:58	Walter Binder
Kaestner Tech Talk	08 Aug 2012 - 19:23	Walter Binder
Moor Invited Talk	08 Aug 2012 - 08:01	Klaus Ostermann
P132 Walkingshaw	07 Aug 2012 - 20:31	Walter Binder
P122 Rafkind	07 Aug 2012 - 20:26	Walter Binder
P112 Efftinge	07 Aug 2012 - 20:21	Walter Binder
P103 Bauer	07 Aug 2012 - 20:16	Walter Binder
P93 Bagheri	07 Aug 2012 - 20:11	Walter Binder
P84 Riche	07 Aug 2012 - 20:08	Walter Binder
P80 Freeman	07 Aug 2012 - 20:02	Walter Binder
P70 Zhang	07 Aug 2012 - 19:56	Walter Binder
P60 Spacek	07 Aug 2012 - 19:51	Walter Binder
P50 Axelsen	07 Aug 2012 - 19:45	Walter Binder
P41 Hulette	07 Aug 2012 - 19:40	Walter Binder
P31 Rayside	07 Aug 2012 - 19:34	Walter Binder
P21 Ryssel	07 Aug 2012 - 17:06	Walter Binder
P11 Thum	07 Aug 2012 - 17:02	Walter Binder
P1 Damiani	07 Aug 2012 - 16:56	Walter Binder
Venue Accomodation	20 Jul 2012 - 13:25	Klaus Ostermann
Conference Registration	01 Aug 2011 - 22:13	Peter Kim
Web Statistics	27 Jan 2011 - 07:03	Peter Kim
Workshops	27 Jan 2011 - 06:46	Peter Kim
Web Index	27 Jan 2011 - 06:38	Peter Kim
Tutorial 3 Embedded DSLs	18 Aug 2010 - 11:59	Rob Economopoulos
Tutorial 1 Project Fortress	17 Aug 2010 - 15:29	Rob Economopoulos
Tutorial 4 Agile Efficient DSLs	17 Aug 2010 - 15:27	Rob Economopoulos
Tutorial 6 MPS	17 Aug 2010 - 10:16	Rob Economopoulos
Tutorial 5 Ontologies And SE	17 Aug 2010 - 10:14	Rob Economopoulos
Tutorial 2 Mega Medeling	17 Aug 2010 - 10:11	Rob Economopoulos
Contributor Logos	22 Jun 2010 - 11:14	Rob Economopoulos
Web Custom Menus	19 Feb 2010 - 08:59	Eelco Visser
Web Notify	22 Jul 2007 - 23:56	Robert Glueck

Number of topics: 50

WebCustomMenus (19 Feb 2010 - 08:59 - NEW - EelcoVisser)

WebHome (09 May 2014 - 12:55 - r1.40 - RobVermaas)

13th International Conference on Generative Programming: Concepts & Experiences (GPCE'14)

Collocated with ASE 2014 and SLE 2014
Keynote by Nikolai Tillmann

September 15-16, 2014
Västerås, Sweden

Sponsored by SIGPLAN. GPCE'14 proceedings published by ACM.

TWiki.GPCE14 Web Preferences

The following settings are web preferences of the TWiki.GPCE14 web. These preferences overwrite the site-level preferences in TWikiPreferences, and can be overwritten by user preferences (your personal topic, i.e. TWikiGuest in the TWiki.Main web)

Set WEBTITLE = 2014 International Conference on Generative Programming: Concepts and Experiences
Set SHORTWEBTITLE = GPCE 2014

GPCE variables:

Set URLGPCE12 = http://gpce13.gpce.org
Set GPCEDAYS = October 27-28, 2012
Set GPCEDETAILDAYS = *Main Conference: Oct. 27-28, workshops and tutorials: *

Set URLFLYER =
Set URLFLYERALT = ?
Set URLOOPSLA06 = ?
Set URLLOCAL = ?
Set URLPORTLAND = ?
Set VENUE = ?
Set VENUECITY = Indianapolis, IN, USA

Set PROPOSALSUBMISSION = ?
Set PROPOSALNOTIFICATION = ?

Set TECHTALKSSUBMISSION = Monday, June 4, 2012; 23:55 Honolulu time
Set TECHTALKSNOTIFICATION = Monday, June 18, 2012
Set OLDPAPERPRESUBMISSION = Monday, May 16, 2011
Set OLDPAPERSUBMISSION = Sunday, May 22, 2011
Set PAPERPRESUBMISSION = Monday, April 23, 2012; 23:55 Honolulu time (hard deadline)
Set PAPERSUBMISSION = Monday, April 30, 2012; 23:55 Honolulu time
Set PAPERSUBMISSIONPOSTPONED = ?
Set PAPERNOTIFICATION = Monday, June 4, 2012
Set PAPERCAMERAREADY = Monday, July 9, 2012

Set WORKSHOPSUBMISSION = *??, * (suggested)
Set WORKSHOPNOTIFICATION = *??, * (suggested)
Set WORKSHOPCAMERAREADY = *??, *
Set TUTORIALCAMERAREADY = *??, *

Set EARLYREGISTRATION = *??, *
Set LATEREGISTRATION = *??, *

Set WORKSHOPDAYS = ?

Set GPCEVENUE = Gpce Venue

Preferences:

Set WEBTITLE = Generative Programming: Concepts and Experiences
Set SHORTWEBTITLE = GPCE 2014

List of topics of the TWiki.GPCE14 web:
- Set WEBTOPICLIST = Home | Changes | Index | Search | Go

Web specific background color: (Pick a lighter one of the StandardColors)
- Set WEBBGCOLOR = #D0D0D0

Exclude web from a web="all" search: (Set to on for hidden webs)
- Set NOSEARCHALL =

Default template for new topics and form(s) for this web:
- WebTopicEditTemplate^?: Default template for new topics in this web. (Site-level is used if topic does not exist)
- TWiki.WebTopicEditTemplate: Site-level default template
- TWikiForms: How to enable form(s)
- Set WEBFORMS =

Users or groups who are not / are allowed to view / change / rename topics in the GPCE14 web: (See TWikiAccessControl)
- Set DENYWEBVIEW =
- Set ALLOWWEBVIEW =
- Set DENYWEBCHANGE =
- Set ALLOWWEBCHANGE = GpceorgGroup
- Set DENYWEBRENAME =
- Set ALLOWWEBRENAME = GpceorgGroup

Users or groups allowed to change or rename this WebPreferences topic: (I.e. TWikiAdminGroup)
- Set ALLOWTOPICCHANGE = TWikiAdminGroup GpceorgGroup
- Set ALLOWTOPICRENAME = TWikiAdminGroup GpceorgGroup

Web preferences that are not allowed to be overridden by user preferences:
- Set FINALPREFERENCES = WEBTOPICLIST, DENYWEBVIEW, ALLOWWEBVIEW, DENYWEBCHANGE, ALLOWWEBCHANGE, DENYWEBRENAME, ALLOWWEBRENAME

Notes:

A preference is defined as:
6 spaces * Set NAME = value
Example:
- Set WEBBGCOLOR = #FFFFC0
Preferences are used as TWikiVariables by enclosing the name in percent signs. Example:
- When you write variable %WEBBGCOLOR% , it gets expanded to #D0D0D0 .
The sequential order of the preference settings is significant. Define preferences that use other preferences first, i.e. set WEBCOPYRIGHT before WIKIWEBMASTER since %WEBCOPYRIGHT% uses the %WIKIWEBMASTER% variable.
You can introduce new preferences variables and use them in your topics and templates. There is no need to change the TWiki engine (Perl scripts).

Related Topics:

TWikiPreferences has site-level preferences.
TWikiUsers has a list of user topics. User topics can have optional user preferences.
TWikiVariables has a list of common %VARIABLES%.
TWikiAccessControl explains how to restrict access by users or groups.

WebSearch (08 Aug 2001 - 05:26 - NEW - PeterThoeny)

Number of topics: 0

Topic index: List of GPCE14 topics in alphabetical order.
|All|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|
| All topics in BookView |

Jump to topic: If you already know the name of the topic, enter the name of the topic into the GoBox at the top

WebChanges: Find out what topics in GPCE14 have changed recently

How to edit text:
- Make changes to topics in GoodStyle,
- Learn the TextFormattingRules, and
- Have a look at the TextFormattingFAQ

WebStatistics (27 Jan 2011 - 07:03 - NEW - PeterKim)

HistoricalStatistics^? for TWiki.GPCE14 Web

Month:	Topic views:	Topic saves:	File uploads:	Most popular topic views:	Top contributors for topic save and uploads:

Feb 2008	2643	0	0	512 WebStatistics 302 WebHome 103 WebPreferences 102 WebNews 102 PEPMPublicity^? 102 PEPMProgram^? 75 ProgramCommittee^? 70 CallForPapers 63 PaperSubmission^? 63 ImportantDates 63 PreviousMeetings^?
Jan 2008	9554	0	0	1433 WebHome 786 WebStatistics 660 PEPMProgram^? 433 ProgramCommittee^? 361 PEPMPublicity^? 291 WebNews 283 PreviousMeetings^? 283 RegistrationAndAccomodation^? 265 PaperSubmission^? 265 ImportantDates 260 InvitedTalks^?
Dec 2007	7197	33	0	1314 WebHome 573 PEPMProgram^? 329 WebStatistics 304 ProgramCommittee^? 267 WebNews 254 PEPMPublicity^? 233 AcceptedPapers 213 PaperSubmission^? 204 InvitedTalks^? 201 RegistrationAndAccomodation^? 195 PreviousMeetings^?	32 RobertGlueck 1 OegeDeMoor
Nov 2007	8164	17	0	1673 WebHome 430 WebStatistics 374 AcceptedPapers 344 ImportantDates 335 ProgramCommittee^? 300 WebNews 275 PEPMProgram^? 267 RegistrationAndAccomodation^? 266 PaperSubmission^? 255 InvitedTalks^? 247 PEPMPublicity^?	17 RobertGlueck
Oct 2007	8900	21	1	2412 WebHome 822 PaperSubmission^? 709 ImportantDates 565 CallForPapers 440 ProgramCommittee^? 369 ResearchPaperAdvice^? 232 ToolPaperAdvice^? 217 PEPMPublicity^? 197 InvitedTalks^? 196 WebNews 196 PreviousMeetings^?	22 RobertGlueck
Sep 2007	7368	3	0	1582 WebHome 443 CallForPapers 404 ImportantDates 375 PaperSubmission^? 358 ProgramCommittee^? 332 WebStatistics 254 PEPMPublicity^? 236 PreviousMeetings^? 228 ResearchPaperAdvice^? 200 InvitedTalks^? 198 RegistrationAndAccomodation^?	3 RobertGlueck
Aug 2007	12282	74	10	2082 WebHome 833 ProgramCommittee^? 744 WebStatistics 741 CallForPapers 573 ImportantDates 513 PEPMPublicity^? 433 PaperSubmission^? 416 PEPMProgram^? 409 PreviousMeetings^? 383 ResearchPaperAdvice^? 341 ConferenceOrganization	81 RobertGlueck 3 OegeDeMoor
Jul 2007	3115	144	0	405 WebHome 216 ProgramCommittee^? 159 PreviousMeetings^? 154 CallForPapers 150 WebStatistics 132 ImportantDates 117 PEPMNews^? 112 WebIndex 99 PEPMPublicity^? 96 ConferenceOrganization 80 ResearchPaperAdvice^?	144 RobertGlueck
Jun 2007	5518	0	0	673 WebHome 316 WebStatistics 235 PEPMProgram^? 172 PreviousMeetings^? 154 WebNews 153 WorkshopVenue^? 146 ProgramCommittee^? 142 PaperSubmission^? 134 PEPMPublicity^? 131 AffiliatedMeetings^? 130 AcceptedPapers
May 2007	4489	0	0	530 WebHome 524 WebStatistics 202 PEPMProgram^? 126 PEPMPublicity^? 116 WebNews 115 PreviousMeetings^? 113 ProgramCommittee^? 110 PaperSubmission^? 107 RegistrationAndAccomodation^? 98 AffiliatedMeetings^? 98 WorkshopVenue^?
Apr 2007	4460	0	0	606 WebHome 358 WebStatistics 172 PEPMProgram^? 135 ProgramCommittee^? 121 WebNews 121 PEPMPublicity^? 121 ToolPaperAdvice^? 119 PreviousMeetings^? 115 CallForPapers 109 PaperSubmission^? 105 WebChanges
Mar 2007	4825	0	0	593 WebHome 454 WebStatistics 202 PEPMProgram^? 152 ProgramCommittee^? 128 WebNews 118 PublicityList06^? 116 PaperSubmission^? 110 AffiliatedMeetings^? 109 ResearchPaperAdvice^? 108 WebChanges 103 PreviousMeetings^?
Feb 2007	4464	0	0	661 WebHome 344 WebStatistics 261 PEPMProgram^? 158 WebNews 158 ProgramCommittee^? 128 PaperSubmission^? 123 AffiliatedMeetings^? 119 ResearchPaperAdvice^? 118 CallForPapers 116 PEPMPublicity^? 108 ToolPaperAdvice^?
Jan 2007	5169	7	0	1040 WebHome 612 WebStatistics 462 PEPMProgram^? 188 ProgramCommittee^? 148 WebNews 133 PEPMPublicity^? 123 AffiliatedMeetings^? 114 CallForPapers 113 AcceptedPapers 112 PaperSubmission^? 111 ResearchPaperAdvice^?	7 EelcoVisser
Dec 2006	4452	17	0	1122 WebHome 398 PEPMProgram^? 164 ProgramCommittee^? 140 AcceptedPapers 134 RegistrationAndAccomodation^? 126 ResearchPaperAdvice^? 118 WebStatistics 115 ImportantDates 114 CallForPapers 101 WebNews 98 ToolPaperAdvice^?	17 EelcoVisser
Nov 2006	3436	5	0	782 WebHome 223 WebStatistics 154 ProgramCommittee^? 141 ImportantDates 136 ResearchPaperAdvice^? 125 CallForPapers 106 ToolPaperAdvice^? 97 PEPMProgram^? 88 AffiliatedMeetings^? 88 InvitedTalks^? 83 PEPMPublicity^?	5 EelcoVisser
Oct 2006	3880	8	0	1065 WebHome 262 ImportantDates 252 CallForPapers 201 PaperSubmission^? 162 ProgramCommittee^? 134 ResearchPaperAdvice^? 121 WebStatistics 111 PEPMPublicity^? 101 PreviousMeetings^? 91 ToolPaperAdvice^? 91 AffiliatedMeetings^?	8 EelcoVisser
Sep 2006	2926	5	0	650 WebHome 176 CallForPapers 146 ImportantDates 136 WebStatistics 116 ProgramCommittee^? 95 ResearchPaperAdvice^? 82 PEPMPublicity^? 76 InvitedTalks^? 72 PaperSubmission^? 69 PreviousMeetings^? 67 ToolPaperAdvice^?	5 EelcoVisser
Aug 2006	4938	0	0	786 WebHome 268 CallForPapers 213 WebStatistics 195 ProgramCommittee^? 176 PaperSubmission^? 171 WebChanges 155 ImportantDates 151 PEPMPublicity^? 148 PreviousMeetings^? 131 WebNotify 124 PEPMProgram^?
Jul 2006	7014	0	0	868 WebHome 350 ProgramCommittee^? 337 WebStatistics 334 CallForPapers 235 PaperSubmission^? 213 PreviousMeetings^? 206 PEPMPublicity^? 194 ImportantDates 189 WebChanges 180 WebNotify 175 RegistrationAndAccomodation^?
Jun 2006	4150	29	2	827 WebHome 261 CallForPapers 233 ProgramCommittee^? 164 WebStatistics 159 ImportantDates 136 PreviousMeetings^? 125 ResearchPaperAdvice^? 119 PaperSubmission^? 116 WebChanges 114 PEPMPublicity^? 104 RegistrationAndAccomodation^?	31 EelcoVisser
May 2006	2620	80	0	427 WebHome 138 ProgramCommittee^? 138 CallForPapers 103 PreviousMeetings^? 103 ImportantDates 78 WorkshopVenue^? 77 ResearchPaperAdvice^? 74 WebChanges 72 WebLeftBar 69 WebNotify 69 AffiliatedMeetings^?	80 EelcoVisser
Apr 2006	15023	8	0	3330 WebHome 1250 CallForPapers 781 WebStatistics 571 ImportantDates 504 ConferenceOrganization 486 CallForTechTalks 468 CallForDemonstrations^? 443 CallForWorkshops^? 414 WebNews 397 ElectronicSubmission^? 393 WebChanges	8 ToddVeldhuizen
Mar 2006	10528	1	0	2345 WebHome 871 CallForPapers 667 WebStatistics 376 ImportantDates 343 CallForTechTalks 325 CallForWorkshops^? 325 ConferenceOrganization 310 WebNews 263 CallForDemonstrations^? 255 WebChanges 244 WebPreferences	1 EelcoVisser
Feb 2006	6534	0	0	1541 WebHome 550 CallForPapers 397 WebStatistics 258 ImportantDates 235 CallForTechTalks 226 ConferenceOrganization 215 CallForDemonstrations^? 212 CallForWorkshops^? 200 WebNews 139 WebLeftBar 129 WebPreferences
Jan 2006	6593	129	5	1553 WebHome 494 CallForPapers 422 WebStatistics 315 ImportantDates 240 WebNews 223 ConferenceOrganization 219 CallForTechTalks 197 WebPreferences 191 CallForWorkshops^? 187 WebLeftBar 152 WebChanges	116 EmirPasalic 17 ToddVeldhuizen 1 ChristaSchwanninger
Dec 2005	5873	38	0	1603 WebHome 535 WebStatistics 292 WebNews 246 CallForPapers 230 WebLeftBar 204 WebPreferences 194 ImportantDates 179 ConferenceHeader 166 WebIndex 160 CallForTechTalks 156 PEPMNews^?	37 EmirPasalic 1 ChristaSchwanninger
Nov 2005	3943	0	0	868 WebStatistics 849 WebHome 147 WebLeftBar 144 WebNews 127 ImportantDates 126 WebPreferences 116 WebChanges 114 CallForPapers 109 ConferenceOrganization 105 WebNotify 92 PEPMNews^?
Oct 2005	3209	33	0	932 WebHome 175 WebNews 127 WebChanges 126 WebPreferences 118 PEPMNews^? 115 WebLeftBar 111 ImportantDates 110 WebNotify 105 WebStatistics 101 ConferenceHeader 99 WebIndex	31 ChristaSchwanninger 2 EugenioMoggi
Sep 2005	1290	18	2	361 WebHome 73 WebNews 55 WebIndex 46 WebNotify 46 WebChanges 41 PEPMNews^? 39 WebChanges500^? 38 WebSearch 38 CallForPapers 37 WebPreferences 36 WebChanges100^?	17 EelcoVisser 3 PradeepikaIrangani
Aug 2005	1526	32	1	481 WebHome 147 WebStatistics 94 ConferenceHeader 86 WebIndex 84 WebNews 75 WebPreferences 69 WebChanges 59 PEPMNews^? 51 WebNotify 49 WebLeftBar 43 WebSearch	20 EelcoVisser 7 MartinBravenboer 5 StanJarzabek 1 PradeepikaIrangani
Jul 2005	1191	0	0	389 WebHome 102 WebNews 74 WebIndex 73 WebChanges 68 WebStatistics 67 PEPMNews^? 57 ConferenceHeader 52 WebSearch 50 WebNotify 50 WebChanges500^? 49 WebChanges200^?
Jun 2005	923	0	0	375 WebHome 86 WebNews 68 WebStatistics 57 WebChanges 46 PEPMNews^? 45 WebNotify 42 WebIndex 39 WebSearch 37 ConferenceHeader 26 WebLeftBar 24 WebChanges500^?
May 2005	848	7	0	371 WebHome 53 WebNews 51 WebStatistics 45 ConferenceHeader 42 PEPMNews^? 38 WebChanges 33 WebIndex 31 WebSearch 26 WebPreferences 24 WebNotify 24 WebLeftBar	7 EelcoVisser
Apr 2005	6648	36	0	2409 WebHome 975 CallForPapers 638 ElectronicSubmission^? 298 GpceTutorialsAndWorkshops^? 242 ImportantDates 181 ConferenceOrganization 148 CallForDemonstrations^? 130 CallForWorkshops^? 110 YoungResearchers^? 102 GraphModelTransformations^? 93 CallForTechTalks	23 AndrewMalton 10 EugenioMoggi 2 RobertGlueck 1 EelcoVisser
Mar 2005	4848	35	1	2091 WebHome 696 CallForPapers 202 ImportantDates 178 ElectronicSubmission^? 153 ConferenceOrganization 152 CallForDemonstrations^? 132 CallForWorkshops^? 131 GpceTutorialsAndWorkshops^? 106 CallForTechTalks 55 PEPMNews^? 52 WebIndex	29 EugenioMoggi 5 RobertGlueck 2 EelcoVisser
Feb 2005	2975	7	0	1164 WebHome 364 CallForPapers 140 ImportantDates 137 ConferenceOrganization 95 CallForWorkshops^? 84 CallForDemonstrations^? 72 CallForTechTalks 50 PEPMNews^? 39 WebNews 39 WebChanges 38 WebNotify	7 EugenioMoggi
Jan 2005	2719	19	0	1375 WebHome 211 CallForPapers 169 ConferenceOrganization 135 ImportantDates 98 CallForWorkshops^? 74 CallForTechTalks 59 PEPMNews^? 45 WebIndex 42 WebChanges 35 WebNews 30 CallForDemonstrations^?	12 EugenioMoggi 7 EelcoVisser
Dec 2004	1546	68	0	707 WebHome 125 ImportantDates 92 ConferenceOrganization 67 ConferenceVenue 60 CallForWorkshops^? 37 WebIndex 36 CallForTechTalks 34 WebPreferences 33 WebNews 32 PEPMNews^? 25 WebChanges	43 EugenioMoggi 13 JeffGray 10 EelcoVisser 2 MartinBravenboer
Nov 2004	836	18	0	407 WebHome 77 ImportantDates 66 ConferenceOrganization 38 ConferenceVenue 31 PEPMNews 28 CallForPapers 25 WebNews 20 ForOrganizers^? 19 WebIndex 9 CallForWorkshops^? 8 ElectronicSubmission^?	11 EelcoVisser 7 EugenioMoggi
Oct 2004	400	30	0	206 WebHome 50 ConferenceOrganization 38 ImportantDates 27 ConferenceVenue 17 ConferenceHeader 14 WebIndex 11 WebContents^? 5 PrintCall^? 4 WebNews 4 CallForPapers 2 GpceTutorials^?	27 EugenioMoggi 2 MoggiE 1 RobertGlueck

Notes:

Do not edit this topic, it is updated automatically. (You can also force an update)
TWikiDocumentation tells you how to enable the automatic updates of the statistics.
Suggestion: You could archive this topic once a year and delete the previous year's statistics from the table.

WebTools (08 Nov 2001 - 09:49 - NEW - TWikiGuest)

Finding topics

RoadMap^?
WebIndex: all topics in the GPCE14 web
WebSearch: find topics

Tracking activity

WebNews: selected changes
WebChanges: recent changes
WebNotify: email notification of changes
WebStatistics: usage counts

Look and feel

WebPreferences: values of variables
WebContents^?: web specific entries in the side bar

Workshops (27 Jan 2011 - 06:46 - NEW - PeterKim)

Workshops will be run by SPLASH this year. See SPLASH 2011 Call for Workshops for more information.

Number of topics: 53

All public webs	Help Advanced search^?
Text body Topic title Both

Important Dates

Scope

Topics

Submissions

Research papers

Tool demonstrations

Tech talks

Workshops

Organization and Committees

CALL FOR TECH TALKS

Important dates

Scope

Submission

September 14, 2013

September 15, 2013

Welcome and Keynote

Session 1: Specialization and Modularity (session chair: Ulrik Pagh Schultz)

Session 2: Variation and Product Lines (session chair: Matthew Flatt)

Session 3: DSLs (session chair: Sebastian Erdweg)

September 16, 2013

Keynote

Session 4: Specialization and Cross-Cutting (session chair: Kenichi Asai)

Session 5: Language Tools (session chair: Jaakko Järvi)

Session 6:

GPCE 2013 will be held at Västerås, Sweden, co-located with ASE 2014.

Biography

Joint GPCE/SLE Keynote

Programming Cloud-connected Mobile Devices

Nikolai Tillmann (Microsoft Research)

Joint GPCE/SLE Keynote

From Language Engineering to Viewpoint Engineering

Colin Atkinson (University of Mannheim)

Biography

Biography

Building mbeddr: a Language Engineering Experiment

Markus Völter

Project Fortress: A Growable Language for Scientists and Engineers

Sukyoung Ryu

Abstract

Author biography

(Mega)modeling Software Language Artifacts

Jean-Marie Favre, Dragan Gašević, Ralf Lämmel

Description

Author bios

Embedded Domain-speciﬁc Language Implementation using Dependent Types

Edwin Brady

Abstract

Author biography

Agile and Efﬁcient Domain-Speciﬁc Languages using Multi-stage Programming in Java Mint

Mathias Ricken, Edwin Westbrook

Abstract

Author bios

Ontologies and Software Language Engineering

Dragan Gašević, Fernando Silva Parreiras, Tobias Walter

Abstract

References

Author bios

Language Definition and Extension with MPS

Markus Völter

Abstract

Author biography

TWiki.GPCE14 Web Preferences

HistoricalStatistics? for TWiki.GPCE14 Web

HistoricalStatistics^? for TWiki.GPCE14 Web